<!doctype html>
<meta charset=utf-8>
<meta name="timeout" content="long">
<title>RTCRtpParameters codecs</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="dictionary-helper.js"></script>
<script src="RTCRtpParameters-helper.js"></script>
<script src="RTCPeerConnection-helper.js"></script>
<script src="./third_party/sdp/sdp.js"></script>
<script>
  'use strict';

  // Test is based on the following editor draft:
  // https://w3c.github.io/webrtc-pc/archives/20170605/webrtc.html

  // The following helper functions are called from RTCRtpParameters-helper.js:
  //   doOfferAnswerExchange
  //   validateSenderRtpParameters

  /*
    5.2.  RTCRtpSender Interface
      interface RTCRtpSender {
        Promise<void>           setParameters(optional RTCRtpParameters parameters);
        RTCRtpParameters        getParameters();
      };

      dictionary RTCRtpParameters {
        DOMString                                 transactionId;
        sequence<RTCRtpEncodingParameters>        encodings;
        sequence<RTCRtpHeaderExtensionParameters> headerExtensions;
        RTCRtcpParameters                         rtcp;
        sequence<RTCRtpCodecParameters>           codecs;
      };

      dictionary RTCRtpCodecParameters {
        [readonly]
        unsigned short payloadType;

        [readonly]
        DOMString      mimeType;

        [readonly]
        unsigned long  clockRate;

        [readonly]
        unsigned short channels;

        [readonly]
        DOMString      sdpFmtpLine;
      };

      getParameters
          - The codecs sequence is populated based on the codecs that have been negotiated
            for sending, and which the user agent is currently capable of sending.

            If setParameters has removed or reordered codecs, getParameters MUST return
            the shortened/reordered list. However, every time codecs are renegotiated by
            a new offer/answer exchange, the list of codecs MUST be restored to the full
            negotiated set, in the priority order indicated by the remote description,
            in effect discarding the effects of setParameters.

      codecs
        - When using the setParameters method, the codecs sequence from the corresponding
          call to getParameters can be reordered and entries can be removed, but entries
          cannot be added, and the RTCRtpCodecParameters dictionary members cannot be modified.
   */

  // Get the first codec from param.codecs.
  // Assert that param.codecs has at least one element
  function getFirstCodec(param) {
    const { codecs } = param;
    assert_greater_than(codecs.length, 0);
    return codecs[0];
  }

  function compareCodecParam(observed, expected) {
    assert_equals(observed.payloadType, expected.payloadType);
    assert_equals(observed.clockRate, expected.clockRate);
    assert_equals(observed.channels, expected.channels);
    // Comparisons of mime-type are case-insensitive (see
    // https://datatracker.ietf.org/doc/html/rfc2045#section-5.1)
    assert_equals(observed.mimeType.toLowerCase(), expected.mimeType.toLowerCase());
    // This is not ideal; Firefox does not store fmtp verbatim, it stores a
    // reserialiaztion of the parsed form. We would like to be able to test
    // the other fields without tripping over that. So, we only test
    // sdpFmtpLine if it is a property of |expected|.
    if (expected.hasOwnProperty('sdpFmtpLine')) {
      assert_equals(observed.sdpFmtpLine, expected.sdpFmtpLine);
    }
  }

  function compareCodecParams(observed, expected) {
    assert_equals(observed.length, expected.length);
    for (let i = 0; i < observed.length; ++i) {
      compareCodecParam(observed[i], expected[i]);
    }
  }

  // Does not support disregarding unsupported codecs in the SDP, so is not
  // suitable for all test-cases.
  function checkCodecsAgainstSDP(codecs, msection) {
    const rtpParameters = SDPUtils.parseRtpParameters(msection);
    const {kind} = SDPUtils.parseMLine(msection);

    assert_not_equals(codecs.length, 0);
    assert_equals(codecs.length, rtpParameters.codecs.length);
    for (let i = 0; i < codecs.length; ++i) {
      const observed = codecs[i];
      const fromSdp = rtpParameters.codecs[i];
      const expected = {
        payloadType: fromSdp.payloadType,
        clockRate: fromSdp.clockRate,
        mimeType: `${kind}/${fromSdp.name}`,
      };
      if (kind == 'audio') {
        expected.channels = fromSdp.channels;
      }
      const fmtps = SDPUtils.matchPrefixAndTrim(msection, `a=fmtp:${fromSdp.payloadType}`);
      if (fmtps.length == 1) {
        expected.sdpFmtpLine = fmtps[0];
      } else {
        // compareCodecParam will check if observed.sdpFmtpLine is undefined if we
        // set this, but will not perform any checks if we do not.
        expected.sdpFmtpLine = undefined;
      }
      compareCodecParam(observed, expected);
    }
  }

['audio', 'video'].forEach(kind => {
  /*
    5.2.  setParameters
      7.  If parameters.encodings.length is different from N, or if any parameter
          in the parameters argument, marked as a Read-only parameter, has a value
          that is different from the corresponding parameter value returned from
          sender.getParameters(), abort these steps and return a promise rejected
          with a newly created InvalidModificationError. Note that this also applies
          to transactionId.
   */
  promise_test(async t => {
    const pc = new RTCPeerConnection();
    t.add_cleanup(() => pc.close());

    const { sender } = pc.addTransceiver(kind);
    await doOfferAnswerExchange(t, pc);

    const param = sender.getParameters();
    validateSenderRtpParameters(param);

    const codec = getFirstCodec(param);

    if(codec.payloadType === undefined) {
      codec.payloadType = 8;
    } else {
      codec.payloadType += 1;
    }

    return promise_rejects_dom(t, 'InvalidModificationError',
      sender.setParameters(param));
  }, `setParameters() with codec.payloadType modified should reject with InvalidModificationError (${kind})`);

  promise_test(async t => {
    const pc = new RTCPeerConnection();
    t.add_cleanup(() => pc.close());
    const { sender } = pc.addTransceiver(kind);
    await doOfferAnswerExchange(t, pc);
    const param = sender.getParameters();
    validateSenderRtpParameters(param);

    const codec = getFirstCodec(param);

    if(codec.mimeType === undefined) {
      codec.mimeType = `${kind}/piedpiper`;
    } else {
      codec.mimeType = `${codec.mimeType}-modified`;
    }

    return promise_rejects_dom(t, 'InvalidModificationError',
      sender.setParameters(param));
  }, `setParameters() with codec.mimeType modified should reject with InvalidModificationError (${kind})`);

  promise_test(async t => {
    const pc = new RTCPeerConnection();
    t.add_cleanup(() => pc.close());
    const { sender } = pc.addTransceiver(kind);
    await doOfferAnswerExchange(t, pc);
    const param = sender.getParameters();
    validateSenderRtpParameters(param);

    const codec = getFirstCodec(param);

    if(codec.clockRate === undefined) {
      codec.clockRate = 8000;
    } else {
      codec.clockRate += 1;
    }

    return promise_rejects_dom(t, 'InvalidModificationError',
      sender.setParameters(param));
  }, `setParameters() with codec.clockRate modified should reject with InvalidModificationError (${kind})`);

  promise_test(async t => {
    const pc = new RTCPeerConnection();
    t.add_cleanup(() => pc.close());
    const { sender } = pc.addTransceiver(kind);
    await doOfferAnswerExchange(t, pc);
    const param = sender.getParameters();
    validateSenderRtpParameters(param);

    const codec = getFirstCodec(param);

    if(codec.channels === undefined) {
      codec.channels = 6;
    } else {
      codec.channels += 1;
    }

    return promise_rejects_dom(t, 'InvalidModificationError',
      sender.setParameters(param));
  }, `setParameters() with codec.channels modified should reject with InvalidModificationError (${kind})`);

  promise_test(async t => {
    const pc = new RTCPeerConnection();
    t.add_cleanup(() => pc.close());
    const { sender } = pc.addTransceiver(kind);
    await doOfferAnswerExchange(t, pc);
    const param = sender.getParameters();
    validateSenderRtpParameters(param);

    const codec = getFirstCodec(param);

    if(codec.sdpFmtpLine === undefined) {
      codec.sdpFmtpLine = 'a=fmtp:98 0-15';
    } else {
      codec.sdpFmtpLine = `${codec.sdpFmtpLine};foo=1`;
    }

    return promise_rejects_dom(t, 'InvalidModificationError',
      sender.setParameters(param));
  }, `setParameters() with codec.sdpFmtpLine modified should reject with InvalidModificationError (${kind})`);

  promise_test(async t => {
    const pc = new RTCPeerConnection();
    t.add_cleanup(() => pc.close());
    const { sender } = pc.addTransceiver(kind);
    await doOfferAnswerExchange(t, pc);
    const param = sender.getParameters();
    validateSenderRtpParameters(param);

    const { codecs } = param;

    codecs.push({
      payloadType: 2,
      mimeType: `${kind}/piedpiper`,
      clockRate: 1000,
      channels: 2
    });

    return promise_rejects_dom(t, 'InvalidModificationError',
      sender.setParameters(param));
  }, `setParameters() with new codecs inserted should reject with InvalidModificationError (${kind})`);

  promise_test(async t => {
    const pc = new RTCPeerConnection();
    t.add_cleanup(() => pc.close());
    const { sender } = pc.addTransceiver(kind);
    await doOfferAnswerExchange(t, pc);
    const param = sender.getParameters();
    validateSenderRtpParameters(param);

    const { codecs } = param;
    codecs.pop();

    return promise_rejects_dom(t, 'InvalidModificationError',
      sender.setParameters(param));
  }, `setParameters() with codecs removed should reject with InvalidModificationError (${kind})`);

  promise_test(async t => {
    const pc = new RTCPeerConnection();
    t.add_cleanup(() => pc.close());
    const { sender } = pc.addTransceiver(kind);
    await doOfferAnswerExchange(t, pc);
    const param = sender.getParameters();
    validateSenderRtpParameters(param);

    const { codecs } = param;
    codecs.reverse();

    return promise_rejects_dom(t, 'InvalidModificationError',
      sender.setParameters(param));
  }, `setParameters() with codecs reordered should reject with InvalidModificationError (${kind})`);

  promise_test(async t => {
    const pc = new RTCPeerConnection();
    t.add_cleanup(() => pc.close());
    const { sender } = pc.addTransceiver(kind);
    await doOfferAnswerExchange(t, pc);
    const param = sender.getParameters();
    validateSenderRtpParameters(param);

    delete param.codecs;

    return promise_rejects_dom(t, 'InvalidModificationError',
      sender.setParameters(param));
  }, `setParameters() with codecs undefined should reject with InvalidModificationError (${kind})`);

  promise_test(async t => {
    const pc1 = new RTCPeerConnection();
    t.add_cleanup(() => pc1.close());
    const pc2 = new RTCPeerConnection();
    t.add_cleanup(() => pc2.close());

    const sender1 = pc1.addTransceiver(kind).sender;
    let param = sender1.getParameters();
    assert_array_equals(param.codecs, [], 'No sender codecs in initial stable state');

    const offer = await pc1.createOffer();
    param = sender1.getParameters();
    assert_array_equals(param.codecs, [], 'No sender codecs in initial stable state (after createOffer)');

    await pc1.setLocalDescription(offer);
    param = sender1.getParameters();
    assert_array_equals(param.codecs, [], 'No sender codecs in initial have-local-offer');

    await pc2.setRemoteDescription(offer);
    const [sender2] = pc2.getSenders();
    param = sender2.getParameters();
    assert_array_equals(param.codecs, [], 'No sender codecs in initial have-remote-offer');

    const answer = await pc2.createAnswer();
    param = sender2.getParameters();
    assert_array_equals(param.codecs, [], 'No sender codecs in initial have-remote-offer (after createAnswer)');
  }, `RTCRtpSender.getParameters() should not have codecs before SDP negotiation completes (${kind})`);

  promise_test(async t => {
    const pc1 = new RTCPeerConnection();
    t.add_cleanup(() => pc1.close());
    const pc2 = new RTCPeerConnection();
    t.add_cleanup(() => pc2.close());

    const receiver1 = pc1.addTransceiver(kind).receiver;
    let param = receiver1.getParameters();
    assert_array_equals(param.codecs, [], 'No receiver codecs in initial stable state');

    const offer = await pc1.createOffer();
    param = receiver1.getParameters();
    assert_array_equals(param.codecs, [], 'No receiver codecs in initial stable state (after createOffer)');

    await pc1.setLocalDescription(offer);
    param = receiver1.getParameters();
    assert_array_equals(param.codecs, [], 'No receiver codecs in initial have-local-offer');

    await pc2.setRemoteDescription(offer);
    const [receiver2] = pc2.getReceivers();
    param = receiver2.getParameters();
    assert_array_equals(param.codecs, [], 'No receiver codecs in initial have-remote-offer');

    const answer = await pc2.createAnswer();
    param = receiver2.getParameters();
    assert_array_equals(param.codecs, [], 'No receiver codecs in initial have-remote-offer (after createAnswer)');
  }, `RTCRtpReceiver.getParameters() should not have codecs before SDP negotiation completes (${kind})`);

  promise_test(async t => {
    const pc1 = new RTCPeerConnection();
    t.add_cleanup(() => pc1.close());
    const pc2 = new RTCPeerConnection();
    t.add_cleanup(() => pc2.close());

    const sender1 = pc1.addTransceiver(kind).sender;
    await exchangeOfferAnswer(pc1, pc2);
    const [sender2] = pc2.getSenders();

    let param = sender1.getParameters();
    assert_array_field(param, 'codecs');
    assert_not_equals(param.codecs.length, 0);
    for (const codec of param.codecs) {
      validateCodecParameters(codec);
    }

    param = sender2.getParameters();
    assert_array_field(param, 'codecs');
    assert_not_equals(param.codecs.length, 0);
    for (const codec of param.codecs) {
      validateCodecParameters(codec);
    }
  }, `RTCRtpSender.getParameters() should have codecs after negotiation (${kind})`);

 promise_test(async t => {
    const pc1 = new RTCPeerConnection();
    t.add_cleanup(() => pc1.close());
    const pc2 = new RTCPeerConnection();
    t.add_cleanup(() => pc2.close());

    const receiver1 = pc1.addTransceiver(kind).receiver;
    await exchangeOfferAnswer(pc1, pc2);
    const [receiver2] = pc2.getReceivers();

    let param = receiver1.getParameters();
    assert_array_field(param, 'codecs');
    assert_not_equals(param.codecs.length, 0);
    for (const codec of param.codecs) {
      validateCodecParameters(codec);
    }

    param = receiver2.getParameters();
    assert_array_field(param, 'codecs');
    assert_not_equals(param.codecs.length, 0);
    for (const codec of param.codecs) {
      validateCodecParameters(codec);
    }
  }, `RTCRtpReceiver.getParameters() should have codecs after negotiation (${kind})`);

  promise_test(async t => {
    const pc = new RTCPeerConnection();
    t.add_cleanup(() => pc.close());

    const { sender } = pc.addTransceiver(kind);
    await doOfferAnswerExchange(t, pc);

    const {codecs} = pc.getReceivers()[0].getParameters();
    const sections = SDPUtils.splitSections(pc.localDescription.sdp);
    checkCodecsAgainstSDP(codecs, sections[1]);
  }, `RTCRtpReceiver.getParameters() codecs should match local SDP (${kind}, offerer)`);

  promise_test(async t => {
    const pc1 = new RTCPeerConnection();
    t.add_cleanup(() => pc1.close());
    const pc2 = new RTCPeerConnection();
    t.add_cleanup(() => pc2.close());

    pc1.addTransceiver(kind);
    await exchangeOfferAnswer(pc1, pc2);

    const {codecs} = pc2.getReceivers()[0].getParameters();
    const sections = SDPUtils.splitSections(pc2.localDescription.sdp);
    checkCodecsAgainstSDP(codecs, sections[1]);
  }, `RTCRtpReceiver.getParameters() codecs should match local SDP (${kind}, answerer)`);
});

  // SDP with unusual payload types and fmtp, and an unknown codec
  const audioSdp = `v=0
o=- 166855176514521964 2 IN IP4 127.0.0.1
s=-
t=0 0
m=audio 9 UDP/TLS/RTP/SAVPF 121 111 0 101
c=IN IP4 0.0.0.0
a=rtcp:9 IN IP4 0.0.0.0
a=ice-ufrag:foobarba
a=ice-pwd:foobarba
a=fingerprint:sha-256 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00
a=setup:passive
a=mid:mid1
a=sendrecv
a=rtcp-rsize
a=rtpmap:101 telephone-event/8000/1
a=rtpmap:121 flarglblurp/8000/2
a=rtpmap:111 opus/48000/2
a=fmtp:111 maxaveragebitrate=20001;unknownparam=foo
`;

  // SDP with unusual payload types and fmtp, and an unknown codec
  const videoSdp = `v=0
o=- 1878890426675213188 2 IN IP4 127.0.0.1
s=-
t=0 0
m=video 9 UDP/TLS/RTP/SAVPF 116 117 120 124 119 123 122 121 118
c=IN IP4 0.0.0.0
a=sendrecv
a=fmtp:117 apt=116
a=fmtp:120 max-fs=12277;max-fr=50;unknownparam=foo
a=fmtp:124 apt=120
a=fmtp:119 max-fs=12266;max-fr=40
a=fmtp:123 apt=119
a=fmtp:118 apt=121
a=ice-pwd:60840251a559417c253d68478b0020fb
a=ice-ufrag:741347dd
a=fingerprint:sha-256 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00
a=setup:passive
a=mid:mid1
a=rtcp-mux
a=rtcp-rsize
a=rtpmap:116 flarglblurp/90000
a=rtpmap:117 rtx/90000
a=rtpmap:120 VP9/90000
a=rtpmap:124 rtx/90000
a=rtpmap:119 VP8/90000
a=rtpmap:123 rtx/90000
a=rtpmap:122 ulpfec/90000
a=rtpmap:121 red/90000
a=rtpmap:118 rtx/90000
`;

  const remoteSdpParamsTests = [
    {
      description: 'audio, no fmtp checks',
      kind: 'audio',
      sdp: audioSdp,
      expectedCodecs: [
        {payloadType: 111, clockRate: 48000, channels: 2, mimeType: 'audio/opus'},
        {payloadType: 0, clockRate: 8000, channels: 1, mimeType: 'audio/pcmu'},
        {payloadType: 101, clockRate: 8000, channels: 1, mimeType: 'audio/telephone-event'},
      ]
    },

    {
      description: 'audio, with fmtp checks',
      kind: 'audio',
      sdp: audioSdp,
      expectedCodecs: [
        {payloadType: 111, clockRate: 48000, channels: 2, mimeType: 'audio/opus', sdpFmtpLine: 'maxaveragebitrate=20001;unknownparam=foo'},
        {payloadType: 0, clockRate: 8000, channels: 1, mimeType: 'audio/pcmu', sdpFmtpLine: undefined},
        {payloadType: 101, clockRate: 8000, channels: 1, mimeType: 'audio/telephone-event', sdpFmtpLine: undefined},
      ]
    },

    {
      description: 'video, minimal fmtp checks',
      kind: 'video',
      sdp: videoSdp,
      expectedCodecs: [
        {payloadType: 120, clockRate: 90000, mimeType: 'video/vp9'},
        {payloadType: 124, clockRate: 90000, mimeType: 'video/rtx', sdpFmtpLine: 'apt=120'},
        {payloadType: 119, clockRate: 90000, mimeType: 'video/vp8'},
        {payloadType: 123, clockRate: 90000, mimeType: 'video/rtx', sdpFmtpLine: 'apt=119'},
        {payloadType: 122, clockRate: 90000, mimeType: 'video/ulpfec'},
        {payloadType: 121, clockRate: 90000, mimeType: 'video/red'},
        {payloadType: 118, clockRate: 90000, mimeType: 'video/rtx', sdpFmtpLine: 'apt=121'},
      ]
    },

    {
      description: 'video, with fmtp checks',
      kind: 'video',
      sdp: videoSdp,
      expectedCodecs: [
        {payloadType: 120, clockRate: 90000, mimeType: 'video/vp9', sdpFmtpLine: 'max-fs=12277;max-fr=50;unknownparam=foo'},
        {payloadType: 124, clockRate: 90000, mimeType: 'video/rtx', sdpFmtpLine: 'apt=120'},
        {payloadType: 119, clockRate: 90000, mimeType: 'video/vp8', sdpFmtpLine: 'max-fs=12266;max-fr=40'},
        {payloadType: 123, clockRate: 90000, mimeType: 'video/rtx', sdpFmtpLine: 'apt=119'},
        {payloadType: 122, clockRate: 90000, mimeType: 'video/ulpfec', sdpFmtpLine: undefined},
        {payloadType: 121, clockRate: 90000, mimeType: 'video/red', sdpFmtpLine: undefined},
        {payloadType: 118, clockRate: 90000, mimeType: 'video/rtx', sdpFmtpLine: 'apt=121'},
      ]
    },
  ];

  remoteSdpParamsTests.forEach(test => {
    promise_test(async t => {
      const pc = new RTCPeerConnection();
      t.add_cleanup(() => pc.close());

      pc.addTransceiver(test.kind, { direction: 'sendrecv'});
      await pc.setLocalDescription();
      const {sender, mid} = pc.getTransceivers()[0];
      await pc.setRemoteDescription({sdp: test.sdp.replace('mid1', mid), type: 'answer'});
      const {codecs} = sender.getParameters();
      compareCodecParams(codecs, test.expectedCodecs);
    }, `RTCRtpSender.getParameters() codecs should match remote SDP (${test.description}, offerer)`);

    promise_test(async t => {
      const pc = new RTCPeerConnection();
      t.add_cleanup(() => pc.close());

      await pc.setRemoteDescription({sdp: test.sdp, type: 'offer'});
      await pc.setLocalDescription();
      const {codecs} = pc.getSenders()[0].getParameters();
      compareCodecParams(codecs, test.expectedCodecs);
    }, `RTCRtpSender.getParameters() codecs should match remote SDP (${test.description}, answerer)`);
  });

</script>
